package com.atguigu.juc1205.fileoperation.EncapsulateCollection;
 
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;

/**
 * 封装集合
 * 对属性和方法的封装可以通过设置它们的可见性来实现，但是对于集合，如何进行封装呢？
 * 提供了一种向类的使用者（客户端）隐藏类中集合的方法，既可以让客户类能够访问到集合中的元素，但是又不让客户类直接修改集合的内容
 * 订单类
 * @author Administrator
 */
public class Order {
	private double orderTotal; //订单总金额
	private Collection<OrderItem> orderItems; //集合对象，存储一个订单中的所有订单项
	
	public Order() {
		this.orderItems = new ArrayList<OrderItem>();
	}
	
    //返回订单项集合
//	public Collection<OrderItem> getOrderItems() {
//		return this.orderItems;
//	}
//	重构后 将Collection改成Iterable，
//	因为在java.lang. Iterable接口中只提供了一个返回迭代器Iterator对象的iterator()方法，
//	没有提供add()、remove()等修改成员的方法。因此，只能遍历集合中的元素，而不能对集合进行修改
	public Iterable<OrderItem> getOrderItems() {
		return this.orderItems;
	}
//	public Iterator<OrderItem> getOrderItemsIterator() {
//		return orderItems.iterator();`
//	}
    //返回订单总金额
	public double getOrderTotal() {
		return this.orderTotal;
	}
	
    //增加订单项，同时增加订单总金额
	public void addOrderItem(OrderItem orderItem) {
		this.orderTotal += orderItem.getTotalPrice();
		orderItems.add(orderItem);
	}
	
    //删除订单项，同时减少订单总金额
	public void removeOrderItem(OrderItem orderItem) {
		this.orderTotal -= orderItem.getTotalPrice();
		orderItems.remove(orderItem);
	}
}
 
//订单项类，省略了很多属性
class OrderItem {
	private double totalPrice; //订单项商品总价格
	
	public OrderItem() {
	}
	
	public OrderItem(double totalPrice) {
		this.totalPrice = totalPrice;
	}
	
	public void setTotalPrice(double totalPrice) {
		this.totalPrice = totalPrice;
	}
	
	public double getTotalPrice() {
		return this.totalPrice;
	}
}
 
class Client {
	public static void main(String args[]) {
		OrderItem orderItem1 = new OrderItem(116.00);
		OrderItem orderItem2 = new OrderItem(234.00);
		OrderItem orderItem3 = new OrderItem(58.00);
		
		Order order = new Order();
		order.addOrderItem(orderItem1);
		order.addOrderItem(orderItem2);
		order.addOrderItem(orderItem3);
		
        //获取订单类中的订单项集合
//		Collection<OrderItem> orderItems = order.getOrderItems();

		System.out.print("订单中各订单项的价格分别为：");
//		重构后 获取Iterable<OrderItem>类型的订单项集合对象
		Iterable<OrderItem> orderItems = order.getOrderItems();

//		重构2 获取遍历订单项集合对象的迭代器
//		Iterator<OrderItem> iterator = order.getOrderItemsIterator();
//		while(iterator.hasNext()) {
//			System.out.print(((OrderItem)iterator.next()).getTotalPrice() + ",");
//		}

		for (Object obj : orderItems) {
			System.out.print(((OrderItem)obj).getTotalPrice() + ",");
		}
		System.out.println("订单总金额为" + order.getOrderTotal());
 
        //通过订单项集合对象的add()方法增加新订单
//		orderItems.add(new OrderItem(100.00));

//		重构后 无法访问Order中的集合，Iterable没有提供add()方法，只能通过Order的addOrderItem()方法增加新元素
		order.addOrderItem(new OrderItem(100.00));
//		Iterator<OrderItem> iteratorNew = orderItems.iterator();
		
		System.out.print("订单中各订单项的价格分别为：");
		for (Object obj : orderItems) {
			System.out.print(((OrderItem)obj).getTotalPrice() + ",");
		}
		System.out.println("增加新项后订单总金额为" + order.getOrderTotal());
	}
}